/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package gmovil_jpa.controladores;

import gmovil_jpa.controladores.exceptions.IllegalOrphanException;
import gmovil_jpa.controladores.exceptions.NonexistentEntityException;
import gmovil_jpa.entidades.OrdenCompra;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import gmovil_jpa.entidades.Usuario;
import gmovil_jpa.entidades.TipoPlazoPago;
import gmovil_jpa.entidades.TipoMedioPago;
import gmovil_jpa.entidades.Proveedor;
import gmovil_jpa.entidades.EstadoOrdenCompra;
import gmovil_jpa.entidades.Empleado;
import gmovil_jpa.entidades.RequerimientoCompra;
import gmovil_jpa.entidades.Remision;
import java.util.ArrayList;
import java.util.List;
import gmovil_jpa.entidades.DetalleOrdenCompra;

/**
 *
 * @author castlerock
 */
public class OrdenCompraJpaController {

    public OrdenCompraJpaController() {
        emf = Persistence.createEntityManagerFactory("gmovil_jpaPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(OrdenCompra ordenCompra) {
        if (ordenCompra.getRemisionList() == null) {
            ordenCompra.setRemisionList(new ArrayList<Remision>());
        }
        if (ordenCompra.getDetalleOrdenCompraList() == null) {
            ordenCompra.setDetalleOrdenCompraList(new ArrayList<DetalleOrdenCompra>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario usuario = ordenCompra.getUsuario();
            if (usuario != null) {
                usuario = em.getReference(usuario.getClass(), usuario.getIdUsuario());
                ordenCompra.setUsuario(usuario);
            }
            Usuario usuario1 = ordenCompra.getUsuario1();
            if (usuario1 != null) {
                usuario1 = em.getReference(usuario1.getClass(), usuario1.getIdUsuario());
                ordenCompra.setUsuario1(usuario1);
            }
            TipoPlazoPago tipoPlazoPago = ordenCompra.getTipoPlazoPago();
            if (tipoPlazoPago != null) {
                tipoPlazoPago = em.getReference(tipoPlazoPago.getClass(), tipoPlazoPago.getIdTipoPlazoPago());
                ordenCompra.setTipoPlazoPago(tipoPlazoPago);
            }
            TipoMedioPago tipoMedioPago = ordenCompra.getTipoMedioPago();
            if (tipoMedioPago != null) {
                tipoMedioPago = em.getReference(tipoMedioPago.getClass(), tipoMedioPago.getIdTipoMedioPago());
                ordenCompra.setTipoMedioPago(tipoMedioPago);
            }
            Proveedor proveedor = ordenCompra.getProveedor();
            if (proveedor != null) {
                proveedor = em.getReference(proveedor.getClass(), proveedor.getIdProveedor());
                ordenCompra.setProveedor(proveedor);
            }
            EstadoOrdenCompra estadoOrdenCompra = ordenCompra.getEstadoOrdenCompra();
            if (estadoOrdenCompra != null) {
                estadoOrdenCompra = em.getReference(estadoOrdenCompra.getClass(), estadoOrdenCompra.getIdEstadoOrdenCompra());
                ordenCompra.setEstadoOrdenCompra(estadoOrdenCompra);
            }
            Empleado empleado = ordenCompra.getEmpleado();
            if (empleado != null) {
                empleado = em.getReference(empleado.getClass(), empleado.getIdEmpleado());
                ordenCompra.setEmpleado(empleado);
            }
            Empleado empleado1 = ordenCompra.getEmpleado1();
            if (empleado1 != null) {
                empleado1 = em.getReference(empleado1.getClass(), empleado1.getIdEmpleado());
                ordenCompra.setEmpleado1(empleado1);
            }
            RequerimientoCompra requerimientoCompra = ordenCompra.getRequerimientoCompra();
            if (requerimientoCompra != null) {
                requerimientoCompra = em.getReference(requerimientoCompra.getClass(), requerimientoCompra.getIdRequerimientoCompra());
                ordenCompra.setRequerimientoCompra(requerimientoCompra);
            }
            List<Remision> attachedRemisionList = new ArrayList<Remision>();
            for (Remision remisionListRemisionToAttach : ordenCompra.getRemisionList()) {
                remisionListRemisionToAttach = em.getReference(remisionListRemisionToAttach.getClass(), remisionListRemisionToAttach.getIdRemision());
                attachedRemisionList.add(remisionListRemisionToAttach);
            }
            ordenCompra.setRemisionList(attachedRemisionList);
            List<DetalleOrdenCompra> attachedDetalleOrdenCompraList = new ArrayList<DetalleOrdenCompra>();
            for (DetalleOrdenCompra detalleOrdenCompraListDetalleOrdenCompraToAttach : ordenCompra.getDetalleOrdenCompraList()) {
                detalleOrdenCompraListDetalleOrdenCompraToAttach = em.getReference(detalleOrdenCompraListDetalleOrdenCompraToAttach.getClass(), detalleOrdenCompraListDetalleOrdenCompraToAttach.getIdDetalleOrdenCompra());
                attachedDetalleOrdenCompraList.add(detalleOrdenCompraListDetalleOrdenCompraToAttach);
            }
            ordenCompra.setDetalleOrdenCompraList(attachedDetalleOrdenCompraList);
            em.persist(ordenCompra);
            if (usuario != null) {
                usuario.getOrdenCompraList().add(ordenCompra);
                usuario = em.merge(usuario);
            }
            if (usuario1 != null) {
                usuario1.getOrdenCompraList().add(ordenCompra);
                usuario1 = em.merge(usuario1);
            }
            if (tipoPlazoPago != null) {
                tipoPlazoPago.getOrdenCompraList().add(ordenCompra);
                tipoPlazoPago = em.merge(tipoPlazoPago);
            }
            if (tipoMedioPago != null) {
                tipoMedioPago.getOrdenCompraList().add(ordenCompra);
                tipoMedioPago = em.merge(tipoMedioPago);
            }
            if (proveedor != null) {
                proveedor.getOrdenCompraList().add(ordenCompra);
                proveedor = em.merge(proveedor);
            }
            if (estadoOrdenCompra != null) {
                estadoOrdenCompra.getOrdenCompraList().add(ordenCompra);
                estadoOrdenCompra = em.merge(estadoOrdenCompra);
            }
            if (empleado != null) {
                empleado.getOrdenCompraList().add(ordenCompra);
                empleado = em.merge(empleado);
            }
            if (empleado1 != null) {
                empleado1.getOrdenCompraList().add(ordenCompra);
                empleado1 = em.merge(empleado1);
            }
            if (requerimientoCompra != null) {
                requerimientoCompra.getOrdenCompraList().add(ordenCompra);
                requerimientoCompra = em.merge(requerimientoCompra);
            }
            for (Remision remisionListRemision : ordenCompra.getRemisionList()) {
                OrdenCompra oldOrdenCompraOfRemisionListRemision = remisionListRemision.getOrdenCompra();
                remisionListRemision.setOrdenCompra(ordenCompra);
                remisionListRemision = em.merge(remisionListRemision);
                if (oldOrdenCompraOfRemisionListRemision != null) {
                    oldOrdenCompraOfRemisionListRemision.getRemisionList().remove(remisionListRemision);
                    oldOrdenCompraOfRemisionListRemision = em.merge(oldOrdenCompraOfRemisionListRemision);
                }
            }
            for (DetalleOrdenCompra detalleOrdenCompraListDetalleOrdenCompra : ordenCompra.getDetalleOrdenCompraList()) {
                OrdenCompra oldOrdenCompraOfDetalleOrdenCompraListDetalleOrdenCompra = detalleOrdenCompraListDetalleOrdenCompra.getOrdenCompra();
                detalleOrdenCompraListDetalleOrdenCompra.setOrdenCompra(ordenCompra);
                detalleOrdenCompraListDetalleOrdenCompra = em.merge(detalleOrdenCompraListDetalleOrdenCompra);
                if (oldOrdenCompraOfDetalleOrdenCompraListDetalleOrdenCompra != null) {
                    oldOrdenCompraOfDetalleOrdenCompraListDetalleOrdenCompra.getDetalleOrdenCompraList().remove(detalleOrdenCompraListDetalleOrdenCompra);
                    oldOrdenCompraOfDetalleOrdenCompraListDetalleOrdenCompra = em.merge(oldOrdenCompraOfDetalleOrdenCompraListDetalleOrdenCompra);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(OrdenCompra ordenCompra) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            OrdenCompra persistentOrdenCompra = em.find(OrdenCompra.class, ordenCompra.getIdOrdenCompra());
            Usuario usuarioOld = persistentOrdenCompra.getUsuario();
            Usuario usuarioNew = ordenCompra.getUsuario();
            Usuario usuario1Old = persistentOrdenCompra.getUsuario1();
            Usuario usuario1New = ordenCompra.getUsuario1();
            TipoPlazoPago tipoPlazoPagoOld = persistentOrdenCompra.getTipoPlazoPago();
            TipoPlazoPago tipoPlazoPagoNew = ordenCompra.getTipoPlazoPago();
            TipoMedioPago tipoMedioPagoOld = persistentOrdenCompra.getTipoMedioPago();
            TipoMedioPago tipoMedioPagoNew = ordenCompra.getTipoMedioPago();
            Proveedor proveedorOld = persistentOrdenCompra.getProveedor();
            Proveedor proveedorNew = ordenCompra.getProveedor();
            EstadoOrdenCompra estadoOrdenCompraOld = persistentOrdenCompra.getEstadoOrdenCompra();
            EstadoOrdenCompra estadoOrdenCompraNew = ordenCompra.getEstadoOrdenCompra();
            Empleado empleadoOld = persistentOrdenCompra.getEmpleado();
            Empleado empleadoNew = ordenCompra.getEmpleado();
            Empleado empleado1Old = persistentOrdenCompra.getEmpleado1();
            Empleado empleado1New = ordenCompra.getEmpleado1();
            RequerimientoCompra requerimientoCompraOld = persistentOrdenCompra.getRequerimientoCompra();
            RequerimientoCompra requerimientoCompraNew = ordenCompra.getRequerimientoCompra();
            List<Remision> remisionListOld = persistentOrdenCompra.getRemisionList();
            List<Remision> remisionListNew = ordenCompra.getRemisionList();
            List<DetalleOrdenCompra> detalleOrdenCompraListOld = persistentOrdenCompra.getDetalleOrdenCompraList();
            List<DetalleOrdenCompra> detalleOrdenCompraListNew = ordenCompra.getDetalleOrdenCompraList();
            List<String> illegalOrphanMessages = null;
            for (Remision remisionListOldRemision : remisionListOld) {
                if (!remisionListNew.contains(remisionListOldRemision)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Remision " + remisionListOldRemision + " since its ordenCompra field is not nullable.");
                }
            }
            for (DetalleOrdenCompra detalleOrdenCompraListOldDetalleOrdenCompra : detalleOrdenCompraListOld) {
                if (!detalleOrdenCompraListNew.contains(detalleOrdenCompraListOldDetalleOrdenCompra)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain DetalleOrdenCompra " + detalleOrdenCompraListOldDetalleOrdenCompra + " since its ordenCompra field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (usuarioNew != null) {
                usuarioNew = em.getReference(usuarioNew.getClass(), usuarioNew.getIdUsuario());
                ordenCompra.setUsuario(usuarioNew);
            }
            if (usuario1New != null) {
                usuario1New = em.getReference(usuario1New.getClass(), usuario1New.getIdUsuario());
                ordenCompra.setUsuario1(usuario1New);
            }
            if (tipoPlazoPagoNew != null) {
                tipoPlazoPagoNew = em.getReference(tipoPlazoPagoNew.getClass(), tipoPlazoPagoNew.getIdTipoPlazoPago());
                ordenCompra.setTipoPlazoPago(tipoPlazoPagoNew);
            }
            if (tipoMedioPagoNew != null) {
                tipoMedioPagoNew = em.getReference(tipoMedioPagoNew.getClass(), tipoMedioPagoNew.getIdTipoMedioPago());
                ordenCompra.setTipoMedioPago(tipoMedioPagoNew);
            }
            if (proveedorNew != null) {
                proveedorNew = em.getReference(proveedorNew.getClass(), proveedorNew.getIdProveedor());
                ordenCompra.setProveedor(proveedorNew);
            }
            if (estadoOrdenCompraNew != null) {
                estadoOrdenCompraNew = em.getReference(estadoOrdenCompraNew.getClass(), estadoOrdenCompraNew.getIdEstadoOrdenCompra());
                ordenCompra.setEstadoOrdenCompra(estadoOrdenCompraNew);
            }
            if (empleadoNew != null) {
                empleadoNew = em.getReference(empleadoNew.getClass(), empleadoNew.getIdEmpleado());
                ordenCompra.setEmpleado(empleadoNew);
            }
            if (empleado1New != null) {
                empleado1New = em.getReference(empleado1New.getClass(), empleado1New.getIdEmpleado());
                ordenCompra.setEmpleado1(empleado1New);
            }
            if (requerimientoCompraNew != null) {
                requerimientoCompraNew = em.getReference(requerimientoCompraNew.getClass(), requerimientoCompraNew.getIdRequerimientoCompra());
                ordenCompra.setRequerimientoCompra(requerimientoCompraNew);
            }
            List<Remision> attachedRemisionListNew = new ArrayList<Remision>();
            for (Remision remisionListNewRemisionToAttach : remisionListNew) {
                remisionListNewRemisionToAttach = em.getReference(remisionListNewRemisionToAttach.getClass(), remisionListNewRemisionToAttach.getIdRemision());
                attachedRemisionListNew.add(remisionListNewRemisionToAttach);
            }
            remisionListNew = attachedRemisionListNew;
            ordenCompra.setRemisionList(remisionListNew);
            List<DetalleOrdenCompra> attachedDetalleOrdenCompraListNew = new ArrayList<DetalleOrdenCompra>();
            for (DetalleOrdenCompra detalleOrdenCompraListNewDetalleOrdenCompraToAttach : detalleOrdenCompraListNew) {
                detalleOrdenCompraListNewDetalleOrdenCompraToAttach = em.getReference(detalleOrdenCompraListNewDetalleOrdenCompraToAttach.getClass(), detalleOrdenCompraListNewDetalleOrdenCompraToAttach.getIdDetalleOrdenCompra());
                attachedDetalleOrdenCompraListNew.add(detalleOrdenCompraListNewDetalleOrdenCompraToAttach);
            }
            detalleOrdenCompraListNew = attachedDetalleOrdenCompraListNew;
            ordenCompra.setDetalleOrdenCompraList(detalleOrdenCompraListNew);
            ordenCompra = em.merge(ordenCompra);
            if (usuarioOld != null && !usuarioOld.equals(usuarioNew)) {
                usuarioOld.getOrdenCompraList().remove(ordenCompra);
                usuarioOld = em.merge(usuarioOld);
            }
            if (usuarioNew != null && !usuarioNew.equals(usuarioOld)) {
                usuarioNew.getOrdenCompraList().add(ordenCompra);
                usuarioNew = em.merge(usuarioNew);
            }
            if (usuario1Old != null && !usuario1Old.equals(usuario1New)) {
                usuario1Old.getOrdenCompraList().remove(ordenCompra);
                usuario1Old = em.merge(usuario1Old);
            }
            if (usuario1New != null && !usuario1New.equals(usuario1Old)) {
                usuario1New.getOrdenCompraList().add(ordenCompra);
                usuario1New = em.merge(usuario1New);
            }
            if (tipoPlazoPagoOld != null && !tipoPlazoPagoOld.equals(tipoPlazoPagoNew)) {
                tipoPlazoPagoOld.getOrdenCompraList().remove(ordenCompra);
                tipoPlazoPagoOld = em.merge(tipoPlazoPagoOld);
            }
            if (tipoPlazoPagoNew != null && !tipoPlazoPagoNew.equals(tipoPlazoPagoOld)) {
                tipoPlazoPagoNew.getOrdenCompraList().add(ordenCompra);
                tipoPlazoPagoNew = em.merge(tipoPlazoPagoNew);
            }
            if (tipoMedioPagoOld != null && !tipoMedioPagoOld.equals(tipoMedioPagoNew)) {
                tipoMedioPagoOld.getOrdenCompraList().remove(ordenCompra);
                tipoMedioPagoOld = em.merge(tipoMedioPagoOld);
            }
            if (tipoMedioPagoNew != null && !tipoMedioPagoNew.equals(tipoMedioPagoOld)) {
                tipoMedioPagoNew.getOrdenCompraList().add(ordenCompra);
                tipoMedioPagoNew = em.merge(tipoMedioPagoNew);
            }
            if (proveedorOld != null && !proveedorOld.equals(proveedorNew)) {
                proveedorOld.getOrdenCompraList().remove(ordenCompra);
                proveedorOld = em.merge(proveedorOld);
            }
            if (proveedorNew != null && !proveedorNew.equals(proveedorOld)) {
                proveedorNew.getOrdenCompraList().add(ordenCompra);
                proveedorNew = em.merge(proveedorNew);
            }
            if (estadoOrdenCompraOld != null && !estadoOrdenCompraOld.equals(estadoOrdenCompraNew)) {
                estadoOrdenCompraOld.getOrdenCompraList().remove(ordenCompra);
                estadoOrdenCompraOld = em.merge(estadoOrdenCompraOld);
            }
            if (estadoOrdenCompraNew != null && !estadoOrdenCompraNew.equals(estadoOrdenCompraOld)) {
                estadoOrdenCompraNew.getOrdenCompraList().add(ordenCompra);
                estadoOrdenCompraNew = em.merge(estadoOrdenCompraNew);
            }
            if (empleadoOld != null && !empleadoOld.equals(empleadoNew)) {
                empleadoOld.getOrdenCompraList().remove(ordenCompra);
                empleadoOld = em.merge(empleadoOld);
            }
            if (empleadoNew != null && !empleadoNew.equals(empleadoOld)) {
                empleadoNew.getOrdenCompraList().add(ordenCompra);
                empleadoNew = em.merge(empleadoNew);
            }
            if (empleado1Old != null && !empleado1Old.equals(empleado1New)) {
                empleado1Old.getOrdenCompraList().remove(ordenCompra);
                empleado1Old = em.merge(empleado1Old);
            }
            if (empleado1New != null && !empleado1New.equals(empleado1Old)) {
                empleado1New.getOrdenCompraList().add(ordenCompra);
                empleado1New = em.merge(empleado1New);
            }
            if (requerimientoCompraOld != null && !requerimientoCompraOld.equals(requerimientoCompraNew)) {
                requerimientoCompraOld.getOrdenCompraList().remove(ordenCompra);
                requerimientoCompraOld = em.merge(requerimientoCompraOld);
            }
            if (requerimientoCompraNew != null && !requerimientoCompraNew.equals(requerimientoCompraOld)) {
                requerimientoCompraNew.getOrdenCompraList().add(ordenCompra);
                requerimientoCompraNew = em.merge(requerimientoCompraNew);
            }
            for (Remision remisionListNewRemision : remisionListNew) {
                if (!remisionListOld.contains(remisionListNewRemision)) {
                    OrdenCompra oldOrdenCompraOfRemisionListNewRemision = remisionListNewRemision.getOrdenCompra();
                    remisionListNewRemision.setOrdenCompra(ordenCompra);
                    remisionListNewRemision = em.merge(remisionListNewRemision);
                    if (oldOrdenCompraOfRemisionListNewRemision != null && !oldOrdenCompraOfRemisionListNewRemision.equals(ordenCompra)) {
                        oldOrdenCompraOfRemisionListNewRemision.getRemisionList().remove(remisionListNewRemision);
                        oldOrdenCompraOfRemisionListNewRemision = em.merge(oldOrdenCompraOfRemisionListNewRemision);
                    }
                }
            }
            for (DetalleOrdenCompra detalleOrdenCompraListNewDetalleOrdenCompra : detalleOrdenCompraListNew) {
                if (!detalleOrdenCompraListOld.contains(detalleOrdenCompraListNewDetalleOrdenCompra)) {
                    OrdenCompra oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra = detalleOrdenCompraListNewDetalleOrdenCompra.getOrdenCompra();
                    detalleOrdenCompraListNewDetalleOrdenCompra.setOrdenCompra(ordenCompra);
                    detalleOrdenCompraListNewDetalleOrdenCompra = em.merge(detalleOrdenCompraListNewDetalleOrdenCompra);
                    if (oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra != null && !oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra.equals(ordenCompra)) {
                        oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra.getDetalleOrdenCompraList().remove(detalleOrdenCompraListNewDetalleOrdenCompra);
                        oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra = em.merge(oldOrdenCompraOfDetalleOrdenCompraListNewDetalleOrdenCompra);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = ordenCompra.getIdOrdenCompra();
                if (findOrdenCompra(id) == null) {
                    throw new NonexistentEntityException("The ordenCompra with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            OrdenCompra ordenCompra;
            try {
                ordenCompra = em.getReference(OrdenCompra.class, id);
                ordenCompra.getIdOrdenCompra();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The ordenCompra with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Remision> remisionListOrphanCheck = ordenCompra.getRemisionList();
            for (Remision remisionListOrphanCheckRemision : remisionListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This OrdenCompra (" + ordenCompra + ") cannot be destroyed since the Remision " + remisionListOrphanCheckRemision + " in its remisionList field has a non-nullable ordenCompra field.");
            }
            List<DetalleOrdenCompra> detalleOrdenCompraListOrphanCheck = ordenCompra.getDetalleOrdenCompraList();
            for (DetalleOrdenCompra detalleOrdenCompraListOrphanCheckDetalleOrdenCompra : detalleOrdenCompraListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This OrdenCompra (" + ordenCompra + ") cannot be destroyed since the DetalleOrdenCompra " + detalleOrdenCompraListOrphanCheckDetalleOrdenCompra + " in its detalleOrdenCompraList field has a non-nullable ordenCompra field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Usuario usuario = ordenCompra.getUsuario();
            if (usuario != null) {
                usuario.getOrdenCompraList().remove(ordenCompra);
                usuario = em.merge(usuario);
            }
            Usuario usuario1 = ordenCompra.getUsuario1();
            if (usuario1 != null) {
                usuario1.getOrdenCompraList().remove(ordenCompra);
                usuario1 = em.merge(usuario1);
            }
            TipoPlazoPago tipoPlazoPago = ordenCompra.getTipoPlazoPago();
            if (tipoPlazoPago != null) {
                tipoPlazoPago.getOrdenCompraList().remove(ordenCompra);
                tipoPlazoPago = em.merge(tipoPlazoPago);
            }
            TipoMedioPago tipoMedioPago = ordenCompra.getTipoMedioPago();
            if (tipoMedioPago != null) {
                tipoMedioPago.getOrdenCompraList().remove(ordenCompra);
                tipoMedioPago = em.merge(tipoMedioPago);
            }
            Proveedor proveedor = ordenCompra.getProveedor();
            if (proveedor != null) {
                proveedor.getOrdenCompraList().remove(ordenCompra);
                proveedor = em.merge(proveedor);
            }
            EstadoOrdenCompra estadoOrdenCompra = ordenCompra.getEstadoOrdenCompra();
            if (estadoOrdenCompra != null) {
                estadoOrdenCompra.getOrdenCompraList().remove(ordenCompra);
                estadoOrdenCompra = em.merge(estadoOrdenCompra);
            }
            Empleado empleado = ordenCompra.getEmpleado();
            if (empleado != null) {
                empleado.getOrdenCompraList().remove(ordenCompra);
                empleado = em.merge(empleado);
            }
            Empleado empleado1 = ordenCompra.getEmpleado1();
            if (empleado1 != null) {
                empleado1.getOrdenCompraList().remove(ordenCompra);
                empleado1 = em.merge(empleado1);
            }
            RequerimientoCompra requerimientoCompra = ordenCompra.getRequerimientoCompra();
            if (requerimientoCompra != null) {
                requerimientoCompra.getOrdenCompraList().remove(ordenCompra);
                requerimientoCompra = em.merge(requerimientoCompra);
            }
            em.remove(ordenCompra);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<OrdenCompra> findOrdenCompraEntities() {
        return findOrdenCompraEntities(true, -1, -1);
    }

    public List<OrdenCompra> findOrdenCompraEntities(int maxResults, int firstResult) {
        return findOrdenCompraEntities(false, maxResults, firstResult);
    }

    private List<OrdenCompra> findOrdenCompraEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(OrdenCompra.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public OrdenCompra findOrdenCompra(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(OrdenCompra.class, id);
        } finally {
            em.close();
        }
    }

    public int getOrdenCompraCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<OrdenCompra> rt = cq.from(OrdenCompra.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
